home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Graphics / Multimedia / Movie3.0 / Source / xanim / xanim_act.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-03  |  21.8 KB  |  777 lines
  1.  
  2. /*
  3.  * xanim_act.c
  4.  *
  5.  * Copyright (C) 1990,1991,1992,1993,1994 by Mark Podlipec. 
  6.  * All rights reserved.
  7.  *
  8.  * This software may be freely copied, modified and redistributed without
  9.  * fee for non-commerical purposes provided that this copyright notice is
  10.  * preserved intact on all copies and modified copies.
  11.  * 
  12.  * There is no warranty or other guarantee of fitness of this software.
  13.  * It is provided solely "as is". The author(s) disclaim(s) all
  14.  * responsibility and liability with respect to this software's usage
  15.  * or its effect upon hardware or computer systems.
  16.  *
  17.  */
  18. #include "xanim.h"
  19. #if XWIN
  20. #include <Intrinsic.h>
  21. #include <StringDefs.h>
  22. #include <Shell.h>
  23. #endif
  24. #include <sys/signal.h>
  25. #ifndef VMS
  26. #include <sys/times.h>
  27. #endif
  28. #include <ctype.h>
  29.  
  30. #ifdef XSHM
  31. #include <sys/ipc.h>
  32. #include <sys/shm.h>
  33. #include <X11/extensions/XShm.h>
  34. #endif /*XSHM*/
  35.  
  36. #if XWIN
  37. #include "xanim_x11.h"
  38. extern Visual     *theVisual;
  39. #endif
  40. extern ULONG shm;
  41.  
  42. extern LONG xa_pixmap_flag;
  43. extern USHORT xa_gamma_adj[];
  44.  
  45. XA_ACTION *ACT_Get_Action();
  46. void ACT_Setup_Mapped();
  47. void ACT_Setup_Packed();
  48. void ACT_Setup_Loop();
  49. void ACT_Make_Images();
  50. void ACT_Add_CHDR_To_Action();
  51. void ACT_Del_CHDR_From_Action();
  52. void ACT_Get_CCMAP();
  53. XA_CHDR *ACT_Get_CMAP();
  54. void ACT_Free_Act();
  55.  
  56. void UTIL_Mapped_To_Bitmap();
  57. void UTIL_Mapped_To_Mapped();
  58. void UTIL_Mapped_To_Floyd();
  59. void UTIL_Pack_Image();
  60. UBYTE *UTIL_Alloc_Scaled();
  61. UBYTE *UTIL_Scale_Mapped();
  62. UBYTE *UTIL_Scale_Bitmap();
  63. ULONG UTIL_Get_Buffer_Scale();
  64. void UTIL_Create_Clip();
  65. void UTIL_Sub_Image();
  66.  
  67.  
  68. XA_ACTION *act_first_cmap = 0;
  69. XA_ACTION *act_cur_cmap = 0;
  70.  
  71.  
  72. /*
  73.  * Allocate, Add to Anim_Hdr and Return an Action.
  74.  */
  75. XA_ACTION *ACT_Get_Action(anim_hdr,type)
  76. XA_ANIM_HDR *anim_hdr;
  77. LONG type;
  78. {
  79.   XA_ACTION *act;
  80.  
  81.   act = (XA_ACTION *)malloc(sizeof(XA_ACTION));
  82.   if (act == 0) TheEnd1("ACT_Get_Action: malloc err\n");
  83.  
  84.   act->type = type;
  85.   act->cmap_rev = 0;
  86.   act->data = 0;
  87.   act->chdr = 0;
  88.   act->h_cmap = 0;
  89.   act->map = 0;
  90.   act->next_same_chdr = 0;
  91.  
  92.   act->next = anim_hdr->acts;  /* insert at front of list */
  93.   anim_hdr->acts = act;
  94.   return(act);
  95. }
  96.  
  97. /*
  98.  *
  99.  */
  100. void
  101. ACT_Setup_Mapped(act,ipic,chdr,xpos,ypos,xsize,ysize,width,height,
  102.         clip_flag,clip_mask,
  103.         free_ipic_flag,full_ipic_flag,already_disp_flag)
  104. XA_ACTION *act;
  105. UBYTE *ipic;
  106. XA_CHDR *chdr;
  107. LONG xpos,ypos,xsize,ysize;    /* image/sub-image dimensions */
  108. LONG width,height;        /* screen dimensions */
  109. ULONG clip_flag;        /* if TRUE then create clip with clip_mask */ 
  110. ULONG clip_mask;        /* transparent pixel value of clip  */
  111. ULONG free_ipic_flag;        /* free ipic before returning */
  112. ULONG full_ipic_flag;        /* full screen given, not just image */
  113. ULONG already_disp_flag;    /* ipic already in display form */
  114. {
  115.   ULONG line_size,buff_x,buff_y,need_to_scale;
  116.   ULONG in_x_size,in_y_size,inline_size,inpix_size,resize_flag;
  117.   LONG map_size;
  118.   UBYTE *t_pic,*clip_ptr;
  119.   ACT_MAPPED_HDR *act_map_hdr;
  120.  
  121.     /* Figure out buffer scaling */
  122.   need_to_scale = UTIL_Get_Buffer_Scale(width,height,&buff_x,&buff_y);
  123.   
  124.     /* get correct input buffer size */
  125.   inpix_size = (already_disp_flag==TRUE)?x11_bytes_pixel:1;
  126.   in_x_size = (full_ipic_flag==TRUE)?width:xsize;
  127.   in_y_size = (full_ipic_flag==TRUE)?height:ysize;
  128.   inline_size = in_x_size * inpix_size;
  129.   if ( (full_ipic_flag == TRUE) && ((xsize != width) || (ysize != height)) )
  130.     resize_flag = TRUE;
  131.   else  resize_flag = FALSE;
  132.  
  133.   DEBUG_LEVEL2 fprintf(stderr,"Setup_Mapped:\n");
  134.   DEBUG_LEVEL2 fprintf(stderr,"  <%ld,%ld> <%ld,%ld>\n",
  135.                 xpos,  ypos, xsize, ysize  );
  136.  
  137.   t_pic = clip_ptr = 0;
  138.   act_map_hdr = (ACT_MAPPED_HDR *) malloc( sizeof(ACT_MAPPED_HDR) );
  139.   if (act_map_hdr == 0) TheEnd1("ACT_Setup_Mapped: malloc err\n");
  140.  
  141.   map_size = (chdr)?(chdr->csize): 0 ;
  142.   line_size = X11_Get_Line_Size(xsize);
  143.  
  144. /*******
  145.  * t_pic should hold image data
  146.  * i_pic should be left unchanged
  147.  * xpos,ypos,xsize,ysize can change and should be correct at break;
  148.  */
  149.   switch (x11_display_type)
  150.   {
  151.     case XA_MONOCHROME:
  152.           /* POD NOTE: Currently assumes ipic always get converted */
  153.     if (need_to_scale == TRUE)
  154.         {
  155.       ULONG xpos_o,ypos_o,xsize_o,ysize_o;
  156.  
  157.       xpos_o = xpos; ypos_o = ypos;
  158.       if (full_ipic_flag == FALSE) xpos = ypos = 0;
  159.       t_pic = UTIL_Alloc_Scaled(xsize,ysize,width,height,
  160.           buff_x,buff_y,1,xpos_o,ypos_o,TRUE);
  161.       if (t_pic)
  162.       {
  163.         UBYTE *p_pic;
  164.         p_pic = UTIL_Alloc_Scaled(xsize,ysize,width,height,
  165.           buff_x,buff_y,1,xpos_o,ypos_o,FALSE);
  166.         UTIL_Scale_Mapped(p_pic,ipic,xpos,ypos,xsize,ysize,
  167.             inline_size,width,height,buff_x,buff_y,
  168.             inpix_size,&xpos_o,&ypos_o,&xsize_o,&ysize_o,0);
  169.             xpos = xpos_o; ypos = ypos_o; xsize = xsize_o; ysize = ysize_o;
  170.         UTIL_Mapped_To_Bitmap(t_pic,p_pic,chdr, xpos,ypos,
  171.             xsize,ysize,buff_x,buff_y, X11_Get_Line_Size(xsize));
  172.         act->type = ACT_DISP; act_map_hdr->psize = 0;
  173.         if (clip_flag == TRUE)
  174.         {
  175.           clip_ptr = (UBYTE *) 
  176.             malloc(ysize * (X11_Get_Bitmap_Width(xsize)/8) );
  177.           if (clip_ptr==0) TheEnd1("Setup_Mapped: clip malloc err\n");
  178.           UTIL_Create_Clip(clip_ptr,p_pic,clip_mask,xsize,ysize,
  179.             inpix_size,X11_Get_Bitmap_Width(xsize),X11_LSB);
  180.         }
  181.         if (p_pic) { FREE(p_pic,0x106); p_pic = 0; }
  182.           }
  183.       else /* scale to zero size */
  184.       {
  185.         act->type = ACT_NOP;    clip_flag = FALSE;
  186.         FREE(act_map_hdr,0x107);    act_map_hdr = 0;
  187.       }
  188.         } /* end of need to scale */
  189.     else
  190.     {
  191.       t_pic = (UBYTE *) malloc(ysize * line_size);
  192.       if (t_pic == 0) TheEnd1("X11_Get_Image: t_pic malloc failed.\n");
  193.       UTIL_Mapped_To_Bitmap(t_pic,ipic,chdr,
  194.             xpos,ypos,xsize,ysize,in_x_size,in_y_size,line_size);
  195.       if (clip_flag == TRUE)
  196.       {
  197.         clip_ptr = (UBYTE *) 
  198.             malloc(ysize * (X11_Get_Bitmap_Width(xsize)/8) );
  199.         if (clip_ptr==0) TheEnd1("Setup_Mapped: clip malloc err\n");
  200.         UTIL_Create_Clip(clip_ptr,ipic,clip_mask,xsize,ysize,
  201.             inpix_size,X11_Get_Bitmap_Width(xsize),X11_LSB);
  202.           }
  203.       act->type = ACT_DISP; act_map_hdr->psize = 0;
  204.     }
  205.     break;
  206.     case XA_DIRECTCOLOR:
  207.     case XA_TRUECOLOR:
  208.         inpix_size = x11_bytes_pixel;
  209.     if (clip_flag == TRUE) 
  210.       clip_mask = (chdr)?( chdr->map[clip_mask - chdr->coff] ): 0 ;
  211.     if (need_to_scale == TRUE)
  212.         {
  213.       ULONG xpos_o,ypos_o,xsize_o,ysize_o;
  214.       xpos_o = xpos; ypos_o = ypos;
  215.       if (full_ipic_flag == FALSE) xpos = ypos = 0;
  216.       t_pic = UTIL_Alloc_Scaled(xsize,ysize,width,height,
  217.             buff_x,buff_y,x11_bytes_pixel,xpos_o,ypos_o,FALSE);
  218.       if (t_pic)
  219.       {
  220.         if (already_disp_flag==TRUE) chdr=0;
  221.         UTIL_Scale_Mapped(t_pic,ipic,xpos,ypos,xsize,ysize,
  222.         inline_size,width,height,buff_x,buff_y,x11_bytes_pixel,
  223.         &xpos_o,&ypos_o,&xsize_o,&ysize_o,chdr);
  224.             xpos = xpos_o; ypos = ypos_o; xsize = xsize_o; ysize = ysize_o;
  225.         act->type = ACT_DISP;    act_map_hdr->psize = 8;
  226.       }
  227.       else /* scale to zero size */
  228.       {
  229.         act->type = ACT_NOP;    clip_flag = FALSE;
  230.         FREE(act_map_hdr,0x101);    act_map_hdr = 0;
  231.       }
  232.     }
  233.     else
  234.         {
  235.       if (   (already_disp_flag == FALSE) || (free_ipic_flag == FALSE)
  236.           || (resize_flag == TRUE) )
  237.       { ULONG t_xpos,t_ypos;
  238.         if (resize_flag == FALSE) { t_xpos = t_ypos = 0; }
  239.         else { t_xpos = xpos; t_ypos = ypos; }
  240.         t_pic = (UBYTE *) malloc(ysize * line_size);
  241.         if (t_pic == 0) TheEnd1("X11_Get_Image: t_pic malloc failed.\n");
  242.         if (already_disp_flag == FALSE)
  243.         {
  244.           UTIL_Mapped_To_Mapped(t_pic,ipic,chdr,
  245.             t_xpos,t_ypos,xsize,ysize,in_x_size,in_y_size);
  246.         }
  247.         else  /* either not_full or can't-free, either way copy */
  248.         {
  249.           UTIL_Sub_Image(t_pic,ipic,xsize,ysize,t_xpos,t_ypos,
  250.                         in_x_size,x11_bytes_pixel);
  251.         }
  252.       }
  253.       else t_pic = ipic;
  254.       act->type = ACT_DISP;    act_map_hdr->psize = 0;
  255.         }
  256.     break;
  257.     case XA_STATICGRAY:
  258.     case XA_STATICCOLOR:
  259.     case XA_GRAYSCALE:
  260.     case XA_PSEUDOCOLOR:
  261.     if (need_to_scale == TRUE)
  262.         {
  263.       ULONG xpos_o,ypos_o,xsize_o,ysize_o;
  264.  
  265.       xpos_o = xpos; ypos_o = ypos;
  266.       if (full_ipic_flag == FALSE) xpos = ypos = 0;
  267.       t_pic = UTIL_Alloc_Scaled(xsize,ysize,width,height,
  268.         buff_x,buff_y,x11_bytes_pixel,xpos_o,ypos_o,FALSE);
  269.       if (t_pic)
  270.       {
  271.         UTIL_Scale_Mapped(t_pic,ipic,xpos,ypos,xsize,ysize,
  272.             inline_size,width,height,buff_x,buff_y,
  273.             inpix_size,&xpos_o,&ypos_o,&xsize_o,&ysize_o,0);
  274.             xpos = xpos_o; ypos = ypos_o; xsize = xsize_o; ysize = ysize_o;
  275.         act->type = ACT_MAPPED;    act_map_hdr->psize = 8;
  276.       }
  277.       else /* scale to zero size */
  278.       {
  279.         act->type = ACT_NOP;    clip_flag = FALSE;
  280.         FREE(act_map_hdr,0x102);    act_map_hdr = 0;
  281.       }
  282.         } /* end of need to scale */
  283.         else
  284.         {
  285.       if ( (free_ipic_flag == FALSE) || (full_ipic_flag == FALSE)
  286.           || (resize_flag == TRUE) )
  287.       { ULONG t_xpos,t_ypos;
  288.         if (resize_flag == FALSE) { t_xpos = t_ypos = 0; }
  289.         else { t_xpos = xpos; t_ypos = ypos; }
  290.         t_pic = (UBYTE *) malloc(ysize * line_size);
  291.         if (t_pic == 0) TheEnd1("Setup_Mapped: malloc err 3\n");
  292.             UTIL_Sub_Image(t_pic,ipic,xsize,ysize,t_xpos,t_ypos,
  293.                             in_x_size,inpix_size);
  294.       }
  295.       else t_pic = ipic;
  296.       act->type = ACT_MAPPED;
  297.           act_map_hdr->psize = 8;
  298.         }
  299.     break;
  300.      default:
  301.     fprintf(stderr,"invalid X11 display ?? %lx\n",x11_display_type);
  302.     TheEnd();
  303.   }
  304.  
  305.   if ( (clip_ptr==0) && (clip_flag==TRUE) )
  306.   {
  307.     clip_ptr = (UBYTE *) malloc(ysize * (X11_Get_Bitmap_Width(xsize)/8) );
  308.     if (clip_ptr==0) TheEnd1("Setup_Mapped: clip malloc err\n");
  309.     UTIL_Create_Clip(clip_ptr,t_pic,clip_mask,xsize,ysize,
  310.             inpix_size,X11_Get_Bitmap_Width(xsize),X11_LSB);
  311.   }
  312.  
  313.   act->data = (UBYTE *) act_map_hdr;
  314.   if (act_map_hdr)
  315.   {
  316.     act_map_hdr->xpos = xpos;
  317.     act_map_hdr->ypos = ypos;
  318.     act_map_hdr->xsize = xsize;
  319.     act_map_hdr->ysize = ysize;
  320.     act_map_hdr->data = t_pic;
  321.     act_map_hdr->clip = clip_ptr;
  322.   }
  323.   if ((free_ipic_flag==TRUE) && (t_pic != ipic)) 
  324.                 { FREE(ipic,0x103); ipic = 0; }
  325. }
  326.  
  327. XA_CHDR *ACT_Get_CHDR(rev,csize,coff,msize,moff,cmap_flag,map_flag)
  328. ULONG rev,csize,coff,msize,moff;
  329. ULONG cmap_flag,map_flag;
  330. {
  331.   XA_CHDR *chdr;
  332.  
  333.   chdr = (XA_CHDR *)malloc(sizeof(XA_CHDR));
  334.   if (chdr == 0) TheEnd1("ACT_Get_CHDR: malloc err\n");
  335.  
  336.   DEBUG_LEVEL2 fprintf(stderr,"ACT_Get_CHDR %lx\n",(ULONG)chdr);
  337.  
  338.   chdr->rev    = rev;
  339.   chdr->csize  = csize;
  340.   chdr->coff   = coff;
  341.   chdr->msize  = msize;
  342.   chdr->moff   = moff;
  343.   chdr->next   = 0;
  344.   chdr->acts   = 0;
  345.   chdr->new_chdr = 0;
  346.  
  347.   if ( (csize) && (cmap_flag) )
  348.   {
  349.     chdr->cmap = (ColorReg *)malloc(csize * sizeof(ColorReg));
  350.     if (chdr->cmap == 0) TheEnd1("ACT_Get_CHDR: cmap malloc err\n");
  351.   }
  352.   else
  353.   {
  354.     chdr->cmap = 0;
  355.     if ( (csize==0) && (cmap_flag) )
  356.      fprintf(stderr,"ACT_Get_CHDR: csize 0 err\n");
  357.   }
  358.   if ( (msize) && (map_flag) )
  359.   {
  360.     chdr->map = (ULONG *)malloc(msize * sizeof(ULONG));
  361.     if (chdr->map == 0) TheEnd1("ACT_Get_CHDR: map malloc err\n");
  362.   }
  363.   else
  364.   {
  365.     chdr->map = 0;
  366.     if ( (msize==0) && (map_flag) )
  367.      fprintf(stderr,"ACT_Get_CHDR: msize 0 err\n");
  368.   }
  369.  
  370.   if (xa_chdr_start == 0) xa_chdr_start = chdr;
  371.   else xa_chdr_cur->next = chdr;
  372.   xa_chdr_cur = chdr;
  373.   return(chdr);
  374. }
  375.  
  376. /*
  377.  * Allocate CMAP and put at end of list
  378.  */
  379. XA_CHDR *ACT_Get_CMAP(new_map,csize,coff,msize,moff,rbits,gbits,bbits)
  380. ColorReg *new_map;
  381. ULONG csize,coff,msize,moff;
  382. ULONG rbits,gbits,bbits;
  383. {
  384.   ULONG i;
  385.   XA_CHDR *chdr;
  386.   ULONG rscale,gscale,bscale;
  387.  
  388.   if (   (msize > csize) || (moff < coff) 
  389.       || ( (msize+moff) > (csize+coff) )  )
  390.     TheEnd1("ACT_Get_CMAP: map not in cmap err\n");
  391.  
  392.   chdr = ACT_Get_CHDR(0,csize,coff,msize,moff,TRUE,TRUE);
  393.  
  394.   rscale = cmap_scale[rbits];
  395.   gscale = cmap_scale[gbits];
  396.   bscale = cmap_scale[bbits];
  397.  
  398.   DEBUG_LEVEL2 fprintf(stderr,"c scales %lx %lx %lx\n",rscale,gscale,bscale);
  399.   for(i = 0; i < csize; i++)
  400.   {
  401.     chdr->cmap[i].red   = xa_gamma_adj[ ((rscale * new_map[i].red  ) >> 8) ];
  402.     chdr->cmap[i].green = xa_gamma_adj[ ((gscale * new_map[i].green) >> 8) ];
  403.     chdr->cmap[i].blue  = xa_gamma_adj[ ((bscale * new_map[i].blue ) >> 8) ];
  404.  
  405.     DEBUG_LEVEL3 fprintf(stderr,"%ld) %lx %lx %lx\n",i,
  406.     chdr->cmap[i].red,chdr->cmap[i].green,chdr->cmap[i].blue);
  407.   }
  408.   rscale *= 11;
  409.   gscale *= 16;
  410.   bscale *=  5;
  411.   for(i = 0; i < csize; i++)
  412.   {
  413.     register ULONG d = ( (   rscale * new_map[i].red
  414.                + gscale * new_map[i].green
  415.                + bscale * new_map[i].blue) >> 13 );
  416.     chdr->cmap[i].gray = xa_gamma_adj[ d ];
  417.   }
  418.   if (x11_display_type & XA_X11_TRUE)
  419.   {
  420.     for(i = 0; i < msize; i++)
  421.     {
  422.       register ULONG j;
  423.       j = i + moff - coff;
  424.       chdr->map[i] = X11_Get_True_Color(chdr->cmap[j].red,
  425.             chdr->cmap[j].green,chdr->cmap[j].blue,16);
  426.     }
  427.   }
  428.   else for(i = 0; i < csize; i++) chdr->map[i] = i + moff;
  429.   return(chdr);
  430. }
  431.  
  432. /*
  433.  * Allocate CCMAP and put at end of list
  434.  */
  435. void ACT_Get_CCMAP(act,new_map,csize,coff,rbits,gbits,bbits)
  436. XA_ACTION *act;
  437. ColorReg *new_map;
  438. ULONG csize,coff;
  439. ULONG rbits,gbits,bbits;
  440. {
  441.   ULONG i;
  442.   ACT_CMAP_HDR *act_cmap_hdr;
  443.   ColorReg *act_cmap;
  444.   ULONG rscale,gscale,bscale;
  445.  
  446.   act_cmap_hdr = (ACT_CMAP_HDR *)malloc(sizeof(ACT_CMAP_HDR) + 
  447.                     (csize * sizeof(ColorReg)) );
  448.   if (act_cmap_hdr == 0) TheEnd1("ACT_Get_CCMAP: malloc err");
  449.  
  450.   act->type = ACT_CMAP;
  451.   act->data = (UBYTE *) act_cmap_hdr;
  452.  
  453.   act_cmap_hdr->csize = csize;
  454.   act_cmap_hdr->coff  = coff;
  455.   act_cmap = (ColorReg *)act_cmap_hdr->data;
  456.  
  457.   rscale = cmap_scale[rbits];
  458.   gscale = cmap_scale[gbits];
  459.   bscale = cmap_scale[bbits];
  460.  
  461.   DEBUG_LEVEL2 fprintf(stderr,"c scales %lx %lx %lx\n",rscale,gscale,bscale);
  462.   for(i = 0; i < csize; i++)
  463.   {
  464.     act_cmap[i].red   = xa_gamma_adj[ ((rscale * new_map[i].red  ) >> 8) ];
  465.     act_cmap[i].green = xa_gamma_adj[ ((gscale * new_map[i].green) >> 8) ];
  466.     act_cmap[i].blue  = xa_gamma_adj[ ((bscale * new_map[i].blue ) >> 8) ];
  467.     DEBUG_LEVEL3 fprintf(stderr,"%ld) %lx %lx %lx\n",i,
  468.     act_cmap[i].red,act_cmap[i].green, act_cmap[i].blue);
  469.   }
  470.  
  471.   rscale *= 11;
  472.   gscale *= 16;
  473.   bscale *=  5;
  474.   for(i = 0; i < csize; i++)
  475.   {
  476.     register ULONG d = ( (   rscale * new_map[i].red
  477.                + gscale * new_map[i].green
  478.                + bscale * new_map[i].blue) >> 13 );
  479.     act_cmap[i].gray = xa_gamma_adj[ d ];
  480.   }
  481. }
  482.  
  483.  
  484. void ACT_Add_CHDR_To_Action(act,chdr)
  485. XA_ACTION  *act;
  486. XA_CHDR *chdr;
  487. {
  488.   /* have act use chdr and map */
  489.   act->chdr = chdr;
  490.   act->map  = chdr->map;
  491.   /* add action to chdr's action list */
  492.   act->next_same_chdr = chdr->acts;
  493.   chdr->acts = act;
  494. }
  495.  
  496. void ACT_Del_CHDR_From_Action(act,chdr)
  497. XA_ACTION  *act;
  498. XA_CHDR *chdr;
  499. {
  500.   XA_ACTION *t_act;
  501.   t_act = chdr->acts;
  502.   if (t_act)
  503.   {
  504.     if (t_act == act) chdr->acts = act->next_same_chdr; 
  505.     else
  506.     {
  507.       while (t_act->next_same_chdr)
  508.       {
  509.         if (t_act->next_same_chdr == act) 
  510.         t_act->next_same_chdr = act->next_same_chdr;
  511.         else t_act = t_act->next_same_chdr;
  512.       }  
  513.     }
  514.   }
  515.   act->chdr = 0;
  516.   act->map  = 0;
  517. }
  518.  
  519.  
  520. void ACT_Make_Images(act)
  521. XA_ACTION *act;
  522. {
  523.   ULONG line_size,pixmap_type;
  524.   XImage *image;
  525.   ACT_MAPPED_HDR *act_map_hdr;
  526.  
  527.  
  528.   DEBUG_LEVEL1 fprintf(stderr,"ACT_Make_Images: ");
  529.   while(act)
  530.   {
  531.     DEBUG_LEVEL2 fprintf(stderr,"act %lx \n",act->type);
  532.     switch(act->type)
  533.     {
  534.       case ACT_SETTER:
  535.     if (xa_pixmap_flag == FALSE) act->type = ACT_IMAGES;
  536.     else act->type = ACT_PIXMAPS;
  537.     if (act->chdr)
  538.     {
  539.       if (act->chdr->new_chdr)
  540.       {
  541.         act->chdr = act->chdr->new_chdr;
  542.         act->cmap_rev = act->chdr->rev;
  543.       }
  544.     }
  545.     break;
  546.  
  547.       case ACT_CYCLE:
  548.     if (act->chdr)
  549.     {
  550.       if (act->chdr->new_chdr)
  551.       {
  552.         ACT_CYCLE_HDR *act_cycle;
  553.         ULONG i,size,*i_ptr,moff,*map;
  554.  
  555.         act_cycle = (ACT_CYCLE_HDR *)act->data;
  556.         size = act_cycle->size;
  557.         i_ptr = (ULONG *)(act_cycle->data);
  558.         map    = act->chdr->map;
  559.         moff   = act->chdr->moff;
  560.         for(i=0; i<size; i++)
  561.           i_ptr[i] = map[ (i_ptr[i] - moff) ];
  562.         act->chdr = act->chdr->new_chdr;
  563.         act->cmap_rev = act->chdr->rev;
  564.       }
  565.     }
  566.     break;
  567.  
  568.       case ACT_CMAP:
  569.     if (act->chdr)
  570.     {
  571.       XA_CHDR *new_chdr;
  572.       new_chdr = act->chdr->new_chdr;
  573.       if (new_chdr)
  574.       {
  575.         ACT_CMAP_HDR *old_cmap_hdr,*new_cmap_hdr;
  576.         ColorReg *old_cmap,*new_cmap;
  577.         ULONG i,new_csize,old_csize,old_coff;
  578.  
  579.             DEBUG_LEVEL2
  580.         fprintf(stderr,"ACT_Make_Images remapping CMAP %lx %lx\n",
  581.             (ULONG)act->chdr, (ULONG)new_chdr);
  582.  
  583.         old_cmap_hdr = (ACT_CMAP_HDR *) act->data;
  584.         old_cmap = (ColorReg *)old_cmap_hdr->data;
  585.         old_csize = old_cmap_hdr->csize;
  586.         old_coff  = old_cmap_hdr->coff;
  587.         new_csize = new_chdr->csize;
  588.         /* allocate new cmap_hdr */
  589.         new_cmap_hdr = (ACT_CMAP_HDR *)malloc(sizeof(ACT_CMAP_HDR) +
  590.                     (new_csize * sizeof(ColorReg)) );
  591.         if (new_cmap_hdr == 0)
  592.         TheEnd1("ACT_Make_Images: cmap malloc err");
  593.         new_cmap_hdr->csize = new_csize;
  594.         new_cmap_hdr->coff  = new_chdr->coff;
  595.         new_cmap = (ColorReg *)new_cmap_hdr->data;
  596.         /* remap cmap change based on chdr map */
  597.         memcpy((char*)new_cmap,(char*)new_chdr->cmap,
  598.                     (new_csize * sizeof(ColorReg))); 
  599.         for(i=0; i<old_csize; i++)
  600.         {
  601.           register ULONG d;
  602.           d = act->chdr->map[ i + old_coff - act->chdr->coff ];
  603.           new_cmap[d].red   = old_cmap[i].red;
  604.           new_cmap[d].green = old_cmap[i].green;
  605.           new_cmap[d].blue  = old_cmap[i].blue;
  606.           new_cmap[d].gray  = old_cmap[i].gray;
  607.         }
  608.         FREE(old_cmap_hdr,0x104); old_cmap_hdr = 0;
  609.         act->data = (UBYTE *)new_cmap_hdr;
  610.         act->chdr = new_chdr;
  611.         act->cmap_rev = act->chdr->rev;
  612.           } /* end of new chdr */
  613.         } /* end of chdr */
  614.     break;
  615.       case ACT_MAPPED:
  616.     if (act->chdr)
  617.     {
  618.       if (act->chdr->new_chdr)
  619.       {
  620.             DEBUG_LEVEL2
  621.         fprintf(stderr,"ACT_Make_Images remapping MAPPED %lx %lx\n",
  622.             (ULONG)act->chdr, (ULONG)act->chdr->new_chdr);
  623.  
  624.         act_map_hdr = (ACT_MAPPED_HDR *) act->data;
  625.         /* POD TEMP currently assumes same size mapping */
  626.             if (cmap_dither_type == CMAP_DITHER_FLOYD)
  627.             {
  628.           UTIL_Mapped_To_Floyd(act_map_hdr->data,act_map_hdr->data,
  629.           act->chdr->new_chdr,act->chdr,
  630.           0,0,act_map_hdr->xsize,act_map_hdr->ysize,
  631.           act_map_hdr->xsize,act_map_hdr->ysize);
  632.             }
  633.             else
  634.             {
  635.           UTIL_Mapped_To_Mapped(act_map_hdr->data,act_map_hdr->data,
  636.           act->chdr,
  637.           0,0,act_map_hdr->xsize,act_map_hdr->ysize,
  638.           act_map_hdr->xsize,act_map_hdr->ysize);
  639.         }
  640.         /* update chdr ptrs and revs */
  641.         act->chdr = act->chdr->new_chdr;
  642.         act->cmap_rev = act->chdr->rev;
  643.       } 
  644.       else if (x11_bytes_pixel > 1) /* need to map anyways */
  645.       {
  646. DEBUG_LEVEL2 fprintf(stderr,"ACT_Make_Images kludge remapping MAPPED\n");
  647.  
  648.         act_map_hdr = (ACT_MAPPED_HDR *) act->data;
  649.         UTIL_Mapped_To_Mapped(act_map_hdr->data,act_map_hdr->data,
  650.           act->chdr,
  651.           0,0,act_map_hdr->xsize,act_map_hdr->ysize,
  652.           act_map_hdr->xsize,act_map_hdr->ysize);
  653.       }
  654.     }
  655.     /* fall through */
  656.       case ACT_DISP:
  657.       {
  658.         ACT_IMAGE_HDR *act_im_hdr;
  659.  
  660.     act_im_hdr = (ACT_IMAGE_HDR *) malloc( sizeof(ACT_IMAGE_HDR) );
  661.     if (act_im_hdr == 0) TheEnd1("ACT_Make_Images: malloc err 1\n");
  662.     act_map_hdr = (ACT_MAPPED_HDR *) act->data;
  663.     line_size = X11_Get_Line_Size(act_map_hdr->xsize);
  664.     if (x11_display_type == XA_MONOCHROME) pixmap_type = XYPixmap;
  665.     else pixmap_type = ZPixmap;
  666.  
  667.     if (x11_pack_flag == TRUE) /* PACK */
  668.     {
  669.           UTIL_Pack_Image(act_map_hdr->data,act_map_hdr->data,
  670.               act_map_hdr->xsize,act_map_hdr->ysize);
  671.       if (x11_bits_per_pixel==2) line_size = (line_size + 3) / 4;
  672.           else if (x11_bits_per_pixel==4) line_size = (line_size + 1) / 2;
  673.     }
  674.  
  675.     {
  676.       image = XCreateImage(theDisp, theVisual,
  677.         x11_depth,pixmap_type,0,NULL,
  678.         act_map_hdr->xsize, act_map_hdr->ysize,
  679.         x11_bitmap_pad, line_size);
  680.       if (image == 0) TheEnd1("ACT_Make_Images: XCreateImage err\n");
  681.       image->data = (char *)act_map_hdr->data;
  682.     }
  683.     act->type = ACT_IMAGE;
  684.     act->data = (UBYTE *) act_im_hdr;
  685.     act_im_hdr->xpos = act_map_hdr->xpos;
  686.     act_im_hdr->ypos = act_map_hdr->ypos;
  687.     act_im_hdr->xsize = act_map_hdr->xsize;
  688.     act_im_hdr->ysize = act_map_hdr->ysize;
  689.     act_im_hdr->image = image;
  690.     act_im_hdr->clip  = act_map_hdr->clip;
  691.       }
  692.       FREE(act_map_hdr,0x105); act_map_hdr = 0;
  693.       break;
  694.     } /* end of switch */
  695.     act = act->next;
  696.   } /* end of while act */
  697. }
  698.  
  699. void ACT_Setup_Loop(begin_act,end_act,count,begin_frame,end_frame)
  700. XA_ACTION *begin_act,*end_act;
  701. ULONG count,begin_frame,end_frame;
  702. {
  703.   ACT_BEG_LP_HDR *beg_loop;
  704.   ACT_END_LP_HDR *end_loop;
  705.  
  706.   begin_act->type = ACT_BEG_LP;
  707.   beg_loop = (ACT_BEG_LP_HDR *)malloc(sizeof(ACT_BEG_LP_HDR));
  708.   if (beg_loop == 0) TheEnd1("ACT_Setup_Loop: malloc err0");
  709.   begin_act->data = (UBYTE *)beg_loop;
  710.   beg_loop->count = count;
  711.   beg_loop->cnt_var = 0;
  712.   beg_loop->end_frame = end_frame;
  713.  
  714.   end_act->type = ACT_END_LP;
  715.   end_loop = (ACT_END_LP_HDR *)malloc(sizeof(ACT_END_LP_HDR));
  716.   if (end_loop == 0) TheEnd1("ACT_Setup_Loop: malloc err1");
  717.   end_act->data = (UBYTE *)end_loop;
  718.   end_loop->count = &(beg_loop->count);
  719.   end_loop->cnt_var = &(beg_loop->cnt_var);
  720.   end_loop->begin_frame = begin_frame;
  721.   end_loop->end_frame = &(beg_loop->end_frame);
  722.   end_loop->prev_end_act = 0;
  723. }
  724.  
  725. void ACT_Free_Act(act)
  726. XA_ACTION *act;
  727. {
  728.   if (act)
  729.   {
  730.     switch(act->type)
  731.     {
  732.       case ACT_IMAGE:
  733.         {
  734.           ACT_IMAGE_HDR *act_im_hdr;
  735.           act_im_hdr = (ACT_IMAGE_HDR *)(act->data);
  736.           if (act_im_hdr->image) XDestroyImage(act_im_hdr->image);
  737.           if (act_im_hdr->clip) 
  738.         { FREE(act_im_hdr->clip,0x01); act_im_hdr->clip = 0; }
  739.           XSync(theDisp,False);
  740.           FREE(act->data,0x01); act->data = 0;
  741.         }
  742.         break;
  743.       case ACT_PIXMAP:
  744.         {
  745.           ACT_PIXMAP_HDR *act_pm_hdr;
  746.           act_pm_hdr = (ACT_PIXMAP_HDR *)(act->data);
  747.           if (act_pm_hdr->pixmap) XFreePixmap(theDisp,act_pm_hdr->pixmap);
  748.           if (act_pm_hdr->clip)   XFreePixmap(theDisp,act_pm_hdr->clip);
  749.           XSync(theDisp,False);
  750.           FREE(act->data,0x01); act->data = 0;
  751.           DEBUG_LEVEL2 fprintf(stderr,"  freed ACT_PIXMAP\n");
  752.         }
  753.         break;
  754.       case ACT_SETTER:
  755.       case ACT_IMAGES:
  756.       case ACT_PIXMAPS:
  757.         {
  758.           ACT_SETTER_HDR *act_pms_hdr,*tmp_pms_hdr;
  759.           act_pms_hdr = (ACT_SETTER_HDR *)(act->data);
  760.           while(act_pms_hdr)
  761.           {
  762.             tmp_pms_hdr = act_pms_hdr;
  763.             FREE(act_pms_hdr,0x01);
  764.             act_pms_hdr = act_pms_hdr->next;
  765.           }
  766.         }
  767.         break;
  768.       default:
  769.         if (act->data != 0) { FREE(act->data,0x01); act->data = 0; }
  770.         break;
  771.     } /* end of switch */
  772.     act->data = 0;
  773.     act->type = ACT_NOP;
  774.   }
  775. }
  776.  
  777.